import { BaseErr, util, InsideErr } from "utils";
import { requestNewCookie, requestCardInfo } from "./handleRequest";
import { WifiFlowCookie } from "../const";
const db = uniCloud.database();
const collection = db.collection("token-valid");

// 获取db 缓存
async function getDbCache(): Promise<[err?: BaseErr, data?: any]> {
    let [err, res] = await util.awaitWrap(
        collection
            .where({
                "token-type": WifiFlowCookie,
            })
            .limit(1)
            .get()
    );
    if (err) {
        return [new InsideErr(err), undefined];
    }
    let { data = [] } = res || {};
    return [undefined, data[0]];
}

// 更新cookie
async function updateCookie(cookie: string, docId?: string): Promise<string | undefined> {
    if (docId) {
        // 更新
        await collection.doc(docId).update({
            valid: true,
            token: cookie,
            update: util.baseDateDes(new Date())
        });
        return docId;
    } else {
        // 新增
        let res = await collection.add({
            token: cookie,
            "token-type": WifiFlowCookie,
            valid: true,
            update: util.baseDateDes(new Date())
        });
        res = res || {};
        return res.id;
    }
}

// 获取钉钉token
async function getFlowCookie(): Promise<
    [err?: BaseErr, data?: { id?: string; token?: string; valid: boolean }]
> {
    let [err, data] = await getDbCache();
    if (!util.nilValue(err)) {
        return [err, undefined];
    }

    let wifiFlow: { id?: string; token?: string; valid: boolean } | undefined = undefined;
    if (data) {
        wifiFlow = {
            token: data.token,
            valid: data.valid,
            id: data._id,
        };
    }
    return [undefined, wifiFlow];
}

// 初始控制流, 加载新cookie
async function initialControl(docId?: string): Promise<[err?: BaseErr, data?: any]> {
    // token 无效了, 要请求
    let [new_err, new_data] = await requestNewCookie();
    if (!util.nilValue(new_err)) {
        return [new_err, undefined];
    }
    // 有新 cookie了,  写入
    let updateDocId = await updateCookie(new_data, docId);
    // 新的 cookie 可能又 立即失效了...
    let [req_err, req_data] = await requestCardInfo(new_data);
    if (!util.nilValue(req_err)) {
        // 把数据库里 更新 为 失效...
        if (updateDocId) {
            await collection.doc(updateDocId).update({
                valid: false,
                update: util.baseDateDes(new Date())
            });
        }
        return [req_err, undefined];
    }
    return [undefined, req_data];
}

// 获取解析后的数据
async function getFlowData(): Promise<[err?: BaseErr, data?: any]> {
    // 获取数据库中的 doc_token
    let [err, token] = await getFlowCookie();
    if (!util.nilValue(err)) {
        return [err, undefined];
    }
    if (!token || token.valid !== true) {
        // token 无效了, 要请求 新cookie
        return await initialControl(token?.id);
    } else {
        // 数据库有 token了,  调用 获取 流量卡信息的接口
        let [req_err, req_data] = await requestCardInfo(token.token ?? "");
        if (!util.nilValue(req_err)) {
            // 先把数据库里 标记 无效
            if (token.id) {
                await collection.doc(token.id).update({
                    valid: false,
                    update: util.baseDateDes(new Date())
                });
            }
            // 再走初始流程
            return await initialControl(token.id);
        }
        // 数据无误
        return [undefined, req_data];
    }
}

export { getFlowData };
